////////////////////////////////////////////////////////////////////////////////////////////////////
/// Copyright (c) 2009 - 2010 RacoonStudios
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy of this
/// software and associated documentation files (the "Software"), to deal in the Software
/// without restriction, including without limitation the rights to use, copy, modify, merge,
/// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
/// to whom the Software is furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in all copies or
/// substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
/// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
/// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
/// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
/// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
/// DEALINGS IN THE SOFTWARE.
////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma once
#ifndef string_h__
#define string_h__

#include "core/types.h"
#include "helper/array.h"
#include "memory/heap.h"
#include "math/float2.h"
#include "math/float4.h"
#include "math/vector2.h"
#include "math/vector3.h"
#include "math/vector4.h"
#include "math/line2.h"
#include "math/line3.h"
#include "math/quaternion.h"
#include "math/plane.h"
#include "math/rectangle.h"
#include "math/matrix.h"

namespace Helper
{
	////////////////////////////////////////////////////////////////////////////////////////////////////
	/// \class	String
	///
	/// \brief	String. 
	///
	/// \todo	Add documentation!
	///
	/// \author	Markus
	/// \date	19.02.2010
	////////////////////////////////////////////////////////////////////////////////////////////////////
	class String
	{
		public:

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void * operator new(size_t size)
			///
			/// \brief	 casting operator. 
			///
			/// \author	Markus
			/// \date	21.02.2010
			///
			/// \param	size	The size. 
			///
			/// \return	The result of the operation. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void * operator new(size_t size);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void operator delete(void * ptr)
			///
			/// \brief	 casting operator. 
			///
			/// \author	Markus
			/// \date	21.02.2010
			///
			/// \param [in,out]	ptr	If non-null, the pointer. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void operator delete(void * ptr);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String()
			///
			/// \brief	Default constructor. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String(const string & rhs)
			///
			/// \brief	Constructor. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	rhs	The right hand side. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String(const String & rhs);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String(const char * str)
			///
			/// \brief	Constructor. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The string. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String(const char * str);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	~String()
			///
			/// \brief	Finaliser. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			~String();






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void operator= (const String & rhs)
			///
			/// \brief	Copy operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	rhs	The right hand side. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void operator = (const String & rhs);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void operator= (const char * str)
			///
			/// \brief	Copy operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The string. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void operator = (const char * str);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void operator+=(const String & rhs)
			///
			/// \brief	Addition operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	rhs	The right hand side. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void operator +=(const String & rhs);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	friend bool operator== (const String & a, const String & b)
			///
			/// \brief	Equality operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	a	a. 
			/// \param	b	The. 
			///
			/// \return	true if the parameters are considered equivalent. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator == (const String & a, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	friend bool operator== (const String & a, const char * str)
			///
			/// \brief	Equality operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	a	a. 
			/// \param	str	The string. 
			///
			/// \return	true if the parameters are considered equivalent. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator == (const String & a, const char * str);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	friend bool operator== (const char * str, const String & b)
			///
			/// \brief	Equality operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The string. 
			/// \param	b	The. 
			///
			/// \return	true if the parameters are considered equivalent. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator == (const char * str, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	friend bool operator!= (const String & a, const String & b)
			///
			/// \brief	Inequality operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	a	a. 
			/// \param	b	The. 
			///
			/// \return	true if the parameters are not considered equivalent. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator != (const String & a, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \property	friend bool operator< (const String & a, const String & b)
			///
			/// \brief	 a value indicating whether the operator<(const string&a,const string&b) 
			///
			/// \return	true if operator<(const string&a,const string&b), false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator <  (const String & a, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	friend bool operator> (const String & a, const String & b)
			///
			/// \brief	Greater-than comparison operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	a	a. 
			/// \param	b	The. 
			///
			/// \return	true if the first parameter is greater than to the second. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator >  (const String & a, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \property	friend bool operator<= (const String & a, const String & b)
			///
			/// \brief	 a value indicating whether the operator<=(const string&a,const string&b) 
			///
			/// \return	true if operator<=(const string&a,const string&b), false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator <= (const String & a, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	friend bool operator>= (const String & a, const String & b)
			///
			/// \brief	Greater-than-or-equal comparison operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	a	a. 
			/// \param	b	The. 
			///
			/// \return	true if the first parameter is greater than or equal to the second. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			friend bool operator >= (const String & a, const String & b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	char operator[](tIndex i) const
			///
			/// \brief	 casting operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	i	The. 
			///
			/// \return	The result of the operation. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			char operator[](tIndex i) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	char & operator[](tIndex index)
			///
			/// \brief	 casting operator. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	index	Zero-based index of the. 
			///
			/// \return	The result of the operation. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			char & operator[](tIndex index);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Reserve(tSize size)
			///
			/// \brief	Reserves. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	size	The size. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Reserve(tSize size);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	tSize Length() const
			///
			/// \brief	Lengthes this object. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			tSize Length() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Clear()
			///
			/// \brief	Clears this object to its blank/initial state. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Clear();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsEmpty() const
			///
			/// \brief	Query if this object is empty. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if empty, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsEmpty() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValid() const
			///
			/// \brief	Query if this object is valid. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValid() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool CopyToBuffer(char * buf, tSize size) const
			///
			/// \brief	Copies to buffer. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param [in,out]	buf	If non-null, the buffer. 
			/// \param	size		The size. 
			///
			/// \return	true if it succeeds, false if it fails. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool CopyToBuffer(char * buf, tSize size) const;






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Add(const String & str)
			///
			/// \brief	Adds str.
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The const String & to add. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Add(const String & str);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Add(const char * str)
			///
			/// \brief	Adds str.
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The const char * to add. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Add(const char * str);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Add(const char * str, tSize chars)
			///
			/// \brief	Adds str.
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str		The const char * to add. 
			/// \param	chars	The tSize to add. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Add(const char * str, tSize chars);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ToLower()
			///
			/// \brief	Converts this object to a lower. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ToLower();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ToUpper()
			///
			/// \brief	Converts this object to a upper. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ToUpper();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void FirstCharToUpper()
			///
			/// \brief	First char to upper. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void FirstCharToUpper();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	tSize Tokenize(const String & space, Array<String> & outTokens) const
			///
			/// \brief	Tokenizes. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	space				The space. 
			/// \param [in,out]	outTokens	the out tokens. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			tSize Tokenize(const String & space, Array<String> & outTokens) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Array<String> Tokenize(const String & space) const
			///
			/// \brief	Tokenizes. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	space	The space. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Array<String> Tokenize(const String & space) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	tSize Tokenize(const String & space, char fence, Array<String> & outTokens) const
			///
			/// \brief	Tokenizes. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	space				The space. 
			/// \param	fence				The fence. 
			/// \param [in,out]	outTokens	the out tokens. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			tSize Tokenize(const String & space, char fence, Array<String> & outTokens) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Array<String> Tokenize(const String & space, char fence) const
			///
			/// \brief	Tokenizes. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	space	The space. 
			/// \param	fence	The fence. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Array<String> Tokenize(const String & space, char fence) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String ExtractRange(tIndex from, tSize chars) const
			///
			/// \brief	Extracts a range. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	from	Source for the. 
			/// \param	chars	The chars. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String ExtractRange(tIndex from, tSize chars) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String ExtractToEnd(tIndex from) const
			///
			/// \brief	Extracts to end described by from. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	from	Source for the. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String ExtractToEnd(tIndex from) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Strip(const String & charset)
			///
			/// \brief	Strips. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset	The charset. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Strip(const String & charset);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	tIndex FindStringIndex(const String & str, tIndex start = 0) const
			///
			/// \brief	Searches for the first string index. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str		The string. 
			/// \param	start	The start. 
			///
			/// \return	The found string index. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			tIndex FindStringIndex(const String & str, tIndex start = 0) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	tIndex FindCharIndex(char c, tIndex start = 0) const
			///
			/// \brief	Searches for the first char index. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c		The character. 
			/// \param	start	The start. 
			///
			/// \return	The found char index. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			tIndex FindCharIndex(char c, tIndex start = 0) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void TerminateAtIndex(tIndex index)
			///
			/// \brief	Terminate at index. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	index	Zero-based index of the. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void TerminateAtIndex(tIndex index);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool ContainsCharFromSet(const String & charset) const
			///
			/// \brief	Query if 'charset' contains char from set. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset	The charset. 
			///
			/// \return	true if it succeeds, false if it fails. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool ContainsCharFromSet(const String & charset) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void TrimLeft(const String & charset)
			///
			/// \brief	Trim left. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset	The charset. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void TrimLeft(const String & charset);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void TrimRight(const String & charset)
			///
			/// \brief	Trim right. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset	The charset. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void TrimRight(const String & charset);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Trim(const String & charset)
			///
			/// \brief	Trims. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset	The charset. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Trim(const String & charset);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ReplaceString(const String & str, const String & sub)
			///
			/// \brief	Replace string. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The string. 
			/// \param	sub	The sub. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ReplaceString(const String & str, const String & sub);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ReplaceChar(char c, char sub)
			///
			/// \brief	Replace char. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c	The character. 
			/// \param	sub	The sub. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ReplaceChar(char c, char sub);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void __cdecl Format(const char * fmt, ...)
			///
			/// \brief	Formats. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	fmt	Describes the format to use. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void __cdecl Format(const char * fmt, ...);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void __cdecl FormatArgList(const char * fmt, va_list args)
			///
			/// \brief	Format argument list. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	fmt		Describes the format to use. 
			/// \param	args	The arguments. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void __cdecl FormatArgList(const char * fmt, va_list args);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool CheckValidCharSet(const String & charset) const
			///
			/// \brief	Check valid char set. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset	The charset. 
			///
			/// \return	true if it succeeds, false if it fails. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool CheckValidCharSet(const String & charset) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ReplaceChars(const String & charset, char replacement)
			///
			/// \brief	Replace chars. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	charset		The charset. 
			/// \param	replacement	The replacement. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ReplaceChars(const String & charset, char replacement);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String Concatenate(const Array<String> & strarray, const String & space)
			///
			/// \brief	Concatenates. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	strarray	The strarray. 
			/// \param	space		The space. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String Concatenate(const Array<String> & strarray, const String & space);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static bool MatchPattern(const String & str, const String & pattern)
			///
			/// \brief	Match pattern. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str		The string. 
			/// \param	pattern	The pattern. 
			///
			/// \return	true if it succeeds, false if it fails. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static bool MatchPattern(const String & str, const String & pattern);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	tIndex HashCode() const
			///
			/// \brief	Hash code. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			tIndex HashCode() const;






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void UTF8ToANSI()
			///
			/// \brief	Utf 8 to a nsi. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void UTF8ToANSI();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ANSIToUTF8()
			///
			/// \brief	Ansi to utf 8. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ANSIToUTF8();






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetCharPtr(const char * ptr)
			///
			/// \brief	Sets a char pointer. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	ptr	The pointer. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetCharPtr(const char * ptr);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Set(const char * ptr, tSize length)
			///
			/// \brief	Sets. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	ptr		The const char * to set. 
			/// \param	length	The tSize to set. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Set(const char * ptr, tSize length);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetInt(int val)
			///
			/// \brief	Sets an int. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetInt(int val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetFloat(float val)
			///
			/// \brief	Sets a float. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetFloat(float val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetBool(bool val)
			///
			/// \brief	Sets a bool. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	true to value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetBool(bool val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetFloat2(const Math::float2 & val)
			///
			/// \brief	Sets a float 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetFloat2(const Math::float2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetFloat4(const Math::float4 & val)
			///
			/// \brief	Sets a float 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetFloat4(const Math::float4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetVector2(const Math::vector2 & val)
			///
			/// \brief	Sets a vector 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetVector2(const Math::vector2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetVector3(const Math::vector3 & val)
			///
			/// \brief	Sets a vector 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetVector3(const Math::vector3 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetVector4(const Math::vector4 & val)
			///
			/// \brief	Sets a vector 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetVector4(const Math::vector4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetQuaternion(const Math::quaternion & val)
			///
			/// \brief	Sets a quaternion. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetQuaternion(const Math::quaternion & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetPoint2(const Math::point2 & val)
			///
			/// \brief	Sets a point 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetPoint2(const Math::point2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetPoint4(const Math::point4 & val)
			///
			/// \brief	Sets a point 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetPoint4(const Math::point4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetLine2(const Math::line2 & val)
			///
			/// \brief	Sets a line 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetLine2(const Math::line2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetLine3(const Math::line3 & val)
			///
			/// \brief	Sets a line 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetLine3(const Math::line3 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetPlane(const Math::plane & val)
			///
			/// \brief	Sets a plane. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetPlane(const Math::plane & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetIntRect(const Math::rectangle<int> & val)
			///
			/// \brief	Sets an int rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetIntRect(const Math::rectangle<int> & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetFloatRect(const Math::rectangle<float> & val)
			///
			/// \brief	Sets a float rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetFloatRect(const Math::rectangle<float> & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void SetMatrix(const Math::matrix & val)
			///
			/// \brief	Sets a matrix. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void SetMatrix(const Math::matrix & val);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddInt(int val)
			///
			/// \brief	Adds an int. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddInt(int val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddFloat(float val)
			///
			/// \brief	Adds a float. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddFloat(float val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddBool(bool val)
			///
			/// \brief	Adds a bool. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	true to value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddBool(bool val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddFloat2(const Math::float2 & val)
			///
			/// \brief	Adds a float 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddFloat2(const Math::float2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddFloat4(const Math::float4 & val)
			///
			/// \brief	Adds a float 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddFloat4(const Math::float4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddVector2(const Math::vector2 & val)
			///
			/// \brief	Adds a vector 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddVector2(const Math::vector2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddVector3(const Math::vector3 & val)
			///
			/// \brief	Adds a vector 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddVector3(const Math::vector3 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddVector4(const Math::vector4 & val)
			///
			/// \brief	Adds a vector 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddVector4(const Math::vector4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddQuaternion(const Math::quaternion & val)
			///
			/// \brief	Adds a quaternion. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddQuaternion(const Math::quaternion & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddPoint2(const Math::point2 & val)
			///
			/// \brief	Adds a point 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddPoint2(const Math::point2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddPoint4(const Math::point4 & val)
			///
			/// \brief	Adds a point 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddPoint4(const Math::point4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddLine2(const Math::line2 & val)
			///
			/// \brief	Adds a line 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddLine2(const Math::line2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddLine3(const Math::line3 & val)
			///
			/// \brief	Adds a line 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddLine3(const Math::line3 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddPlane(const Math::plane & val)
			///
			/// \brief	Adds a plane. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddPlane(const Math::plane & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddIntRect(const Math::rectangle<int> & val)
			///
			/// \brief	Adds an int rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddIntRect(const Math::rectangle<int> & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddFloatRect(const Math::rectangle<float> & val)
			///
			/// \brief	Adds a float rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddFloatRect(const Math::rectangle<float> & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void AddMatrix(const Math::matrix & val)
			///
			/// \brief	Adds a matrix. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void AddMatrix(const Math::matrix & val);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	const char * GetAsCharPtr() const
			///
			/// \brief	Gets as char pointer. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	null if it fails, else as char pointer. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			const char * GetAsCharPtr() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	int GetAsInt() const
			///
			/// \brief	Gets as int. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as int. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			int GetAsInt() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	float GetAsFloat() const
			///
			/// \brief	Gets as float. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as float. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			float GetAsFloat() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool GetAsBool() const
			///
			/// \brief	Gets as bool. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if it succeeds, false if it fails. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool GetAsBool() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::float2 GetAsFloat2() const
			///
			/// \brief	Gets as float 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as float 2. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::float2 GetAsFloat2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::float4 GetAsFloat4() const
			///
			/// \brief	Gets as float 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as float 4. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::float4 GetAsFloat4() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::vector2 GetAsVector2() const
			///
			/// \brief	Gets as vector 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as vector 2. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::vector2 GetAsVector2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::vector3 GetAsVector3() const
			///
			/// \brief	Gets as vector 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as vector 3. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::vector3 GetAsVector3() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::vector4 GetAsVector4() const
			///
			/// \brief	Gets as vector 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as vector 4. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::vector4 GetAsVector4() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::quaternion GetAsQuaternion() const
			///
			/// \brief	Gets as quaternion. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as quaternion. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::quaternion GetAsQuaternion() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::point2 GetAsPoint2() const
			///
			/// \brief	Gets as point 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as point 2. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::point2 GetAsPoint2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::point4 GetAsPoint4() const
			///
			/// \brief	Gets as point 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as point 4. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::point4 GetAsPoint4() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::line2 GetAsLine2() const
			///
			/// \brief	Gets as line 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as line 2. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::line2 GetAsLine2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::line3 GetAsLine3() const
			///
			/// \brief	Gets as line 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as line 3. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::line3 GetAsLine3() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::plane GetAsPlane() const
			///
			/// \brief	Gets as plane. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as plane. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::plane GetAsPlane() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::rectangle<int> GetAsIntRect() const
			///
			/// \brief	Gets as int rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as int rectangle. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::rectangle<int> GetAsIntRect() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::rectangle<float> GetAsFloatRect() const
			///
			/// \brief	Gets as float rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as float rectangle. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::rectangle<float> GetAsFloatRect() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	Math::matrix GetAsMatrix() const
			///
			/// \brief	Gets as matrix. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	as matrix. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			Math::matrix GetAsMatrix() const;






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidInt() const
			///
			/// \brief	Query if this object is valid int. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid int, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidInt() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidFloat() const
			///
			/// \brief	Query if this object is valid float. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid float, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidFloat() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidBool() const
			///
			/// \brief	Query if this object is valid bool. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid bool, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidBool() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidFloat2() const
			///
			/// \brief	Query if this object is valid float 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid float 2, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidFloat2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidFloat4() const
			///
			/// \brief	Query if this object is valid float 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid float 4, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidFloat4() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidVector2() const
			///
			/// \brief	Query if this object is valid vector 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid vector 2, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidVector2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidVector3() const
			///
			/// \brief	Query if this object is valid vector 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid vector 3, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidVector3() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidVector4() const
			///
			/// \brief	Query if this object is valid vector 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid vector 4, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidVector4() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidQuaternion() const
			///
			/// \brief	Query if this object is valid quaternion. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid quaternion, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidQuaternion() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidPoint2() const
			///
			/// \brief	Query if this object is valid point 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid point 2, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidPoint2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidPoint4() const
			///
			/// \brief	Query if this object is valid point 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid point 4, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidPoint4() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidLine2() const
			///
			/// \brief	Query if this object is valid line 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid line 2, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidLine2() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidLine3() const
			///
			/// \brief	Query if this object is valid line 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid line 3, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidLine3() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidPlane() const
			///
			/// \brief	Query if this object is valid plane. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid plane, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidPlane() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidIntRect() const
			///
			/// \brief	Query if this object is valid int rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid int rectangle, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidIntRect() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidFloatRect() const
			///
			/// \brief	Query if this object is valid float rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid float rectangle, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidFloatRect() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool IsValidMatrix() const
			///
			/// \brief	Query if this object is valid matrix. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	true if valid matrix, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool IsValidMatrix() const;






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromInt(int val)
			///
			/// \brief	Initialises this object from the given from int. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromInt(int val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromFloat(float val)
			///
			/// \brief	Initialises this object from the given from float. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromFloat(float val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromBool(bool val)
			///
			/// \brief	Initialises this object from the given from bool. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	true to value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromBool(bool val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromFloat2(const Math::float2 & val)
			///
			/// \brief	Initialises this object from the given from float 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromFloat2(const Math::float2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromFloat4(const Math::float4 & val)
			///
			/// \brief	Initialises this object from the given from float 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromFloat4(const Math::float4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromVector2(const Math::vector2 & val)
			///
			/// \brief	Initialises this object from the given from vector 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromVector2(const Math::vector2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromVector3(const Math::vector3 & val)
			///
			/// \brief	Initialises this object from the given from vector 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromVector3(const Math::vector3 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromVector4(const Math::vector4 & val)
			///
			/// \brief	Initialises this object from the given from vector 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromVector4(const Math::vector4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromQuaternion(const Math::quaternion & val)
			///
			/// \brief	Initialises this object from the given from quaternion. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromQuaternion(const Math::quaternion & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromPoint2(const Math::point2 & val)
			///
			/// \brief	Initialises this object from the given from point 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromPoint2(const Math::point2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromPoint4(const Math::point4 & val)
			///
			/// \brief	Initialises this object from the given from point 4. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromPoint4(const Math::point4 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromLine2(const Math::line2 & val)
			///
			/// \brief	Initialises this object from the given from line 2. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromLine2(const Math::line2 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromLine3(const Math::line3 & val)
			///
			/// \brief	Initialises this object from the given from line 3. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromLine3(const Math::line3 & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromPlane(const Math::plane & val)
			///
			/// \brief	Initialises this object from the given from plane. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromPlane(const Math::plane & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromIntRect(const Math::rectangle<int> & val)
			///
			/// \brief	Initialises this object from the given from int rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromIntRect(const Math::rectangle<int> & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromFloatRect(const Math::rectangle<float> & val)
			///
			/// \brief	Initialises this object from the given from float rectangle. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromFloatRect(const Math::rectangle<float> & val);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static String FromMatrix(const Math::matrix & val)
			///
			/// \brief	Initialises this object from the given from matrix. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	val	The value. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static String FromMatrix(const Math::matrix & val);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String GetFileExtension() const
			///
			/// \brief	Gets the file extension. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	The file extension. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String GetFileExtension() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	bool CheckFileExtension(const String & ext) const
			///
			/// \brief	Check file extension. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	ext	The extent. 
			///
			/// \return	true if it succeeds, false if it fails. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			bool CheckFileExtension(const String & ext) const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ConvertBackslashes()
			///
			/// \brief	Convert backslashes. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ConvertBackslashes();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void StripFileExtension()
			///
			/// \brief	Strip file extension. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void StripFileExtension();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String ExtractFileName() const
			///
			/// \brief	Extracts a file name. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String ExtractFileName() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String ExtractLastDirName() const
			///
			/// \brief	Extracts a last dir name. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String ExtractLastDirName() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String ExtractDirName() const
			///
			/// \brief	Extracts a dir name. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String ExtractDirName() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	String ExtractToLastSlash() const
			///
			/// \brief	Extracts to last slash. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			String ExtractToLastSlash() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void ReplaceIllegalFilenameChars(char replacement)
			///
			/// \brief	Replace illegal filename chars. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	replacement	The replacement. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void ReplaceIllegalFilenameChars(char replacement);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static bool IsDigit(char c)
			///
			/// \brief	Query if 'c' is digit. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c	The character. 
			///
			/// \return	true if digit, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static bool IsDigit(char c);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static bool IsAlpha(char c)
			///
			/// \brief	Query if 'c' is alpha. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c	The character. 
			///
			/// \return	true if alpha, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static bool IsAlpha(char c);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static bool IsAlNum(char c)
			///
			/// \brief	Query if 'c' is al number. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c	The character. 
			///
			/// \return	true if al number, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static bool IsAlNum(char c);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static bool IsLower(char c)
			///
			/// \brief	Query if 'c' is lower. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c	The character. 
			///
			/// \return	true if lower, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static bool IsLower(char c);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static bool IsUpper(char c)
			///
			/// \brief	Query if 'c' is upper. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	c	The character. 
			///
			/// \return	true if upper, false if not. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static bool IsUpper(char c);






			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static int StrCmp(const char * a, const char * b)
			///
			/// \brief	String compare. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	a	a. 
			/// \param	b	The. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static int StrCmp(const char * a, const char * b);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static int StrLen(const char * str)
			///
			/// \brief	String length. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The string. 
			///
			/// \return	. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static int StrLen(const char * str);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	static const char * StrChr(const char * str, int c)
			///
			/// \brief	String chr. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	str	The string. 
			/// \param	c	The. 
			///
			/// \return	null if it fails, else. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			static const char * StrChr(const char * str, int c);

		protected:

		private:

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Delete()
			///
			/// \brief	Deletes this object. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Delete();

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	char * GetLastSlash() const
			///
			/// \brief	Gets the last slash. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \return	null if it fails, else the last slash. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			char * GetLastSlash() const;

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Alloc(tSize size)
			///
			/// \brief	Allocs. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	size	The size. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Alloc(tSize size);

			////////////////////////////////////////////////////////////////////////////////////////////////////
			/// \fn	void Realloc(tSize size)
			///
			/// \brief	Reallocs. 
			///
			/// \author	Markus
			/// \date	19.02.2010
			///
			/// \param	size	The size. 
			////////////////////////////////////////////////////////////////////////////////////////////////////
			void Realloc(tSize size);




			enum
			{
				LocalStringSize = 20
			};

			char * m_heapBuffer;
			char m_localBuffer[LocalStringSize];

			tSize m_strLen;
			tSize m_heapBufferSize;

	};





	///
	static inline String operator + (const String & a, const String & b)
	{
		String result = a;

		result.Add(b);

		return result;
	}

}


#endif // string_h__